module defl.c.ewl.core;

/* This includes definitions from the following:
 *   ewl_enums.h
 *   ewl_object.h
 * 
 */

extern(C):

/**
 * @enum Ewl_Callback_Type
 * This defines the various types of callbacks that can be hooked up for each
 * widget.
 */
enum Ewl_Callback_Type
{
        EWL_CALLBACK_REALIZE, /**< Event when a widget is first drawn */
        EWL_CALLBACK_UNREALIZE, /**< When a widget is no longer drawn */
        EWL_CALLBACK_SHOW, /**< A widget has been marked visible */
        EWL_CALLBACK_HIDE, /**< A widget is marked hidden */
        EWL_CALLBACK_OBSCURE, /**< Widget is offscreen */
        EWL_CALLBACK_REVEAL, /**< Widget returned to screen */
        EWL_CALLBACK_DESTROY, /**< The widget is freed */
        EWL_CALLBACK_CONFIGURE, /**< The object is being resized */
        EWL_CALLBACK_REPARENT, /**< A widget has been placed in a container */
        EWL_CALLBACK_KEY_DOWN, /**< A key was pressed down */
        EWL_CALLBACK_KEY_UP, /**< A key was released */
        EWL_CALLBACK_MOUSE_DOWN, /**< Mouse was pressed down */
        EWL_CALLBACK_MOUSE_UP, /**< Mouse was released */
        EWL_CALLBACK_MOUSE_MOVE, /**< Mouse was moved */
        EWL_CALLBACK_MOUSE_WHEEL, /**< Mouse wheel scrolled */
        EWL_CALLBACK_MOUSE_IN, /**< Mouse was placed over the widget */
        EWL_CALLBACK_MOUSE_OUT, /**< Mouse was moved away from the widget */
        EWL_CALLBACK_CLICKED, /**< Mouse was pressed and released on a widget */
        EWL_CALLBACK_FOCUS_IN, /**< Widget was selected by mouse or key */
        EWL_CALLBACK_FOCUS_OUT, /**< Widget was deselected by mouse or key */
        EWL_CALLBACK_VALUE_CHANGED, /**< Value in widget changed */
        EWL_CALLBACK_STATE_CHANGED, /**< Alter the state of the appearance */
        EWL_CALLBACK_WIDGET_ENABLE, /**< Widget has been re-enabled */
        EWL_CALLBACK_WIDGET_DISABLE, /**< Widget no longer takes input */

        EWL_CALLBACK_MAX /**< Flag to indicate last value */
}

/**
 * @enum Ewl_Event_Notify
 * Flags for the callbacks to indicate interception or notification of the
 * parent.
 */
enum Ewl_Event_Notify
{
        EWL_CALLBACK_NOTIFY_NONE = 0,                /**< No notification or interception */
        EWL_CALLBACK_NOTIFY_NOTIFY = 1,                /**< Notify of call */
        EWL_CALLBACK_NOTIFY_INTERCEPT = 2,        /**< Intercept call */
        EWL_CALLBACK_TYPE_DIRECT = 4                /**< Direct call */
}

/**
 * @enum Ewl_Orientation
 * The orientation enum is used in a few widgets to specify whether the widget
 * should be laid out in a horizontal or vertical fashion.
 */
enum Ewl_Orientation
{
        EWL_ORIENTATION_HORIZONTAL,        /**< Horizontal layout */
        EWL_ORIENTATION_VERTICAL        /**< Vertical layout */
}

/**
 * @enum Ewl_Object_Flags
 * A variety of flags that affect the layout of objects.
 */
enum Ewl_Object_Flags
{
        /*
         * The alignment enumeration allows for specifying how an element is
         * aligned within it's container.
         */
        EWL_FLAG_ALIGN_CENTER = 0, /**< Center align bit */
        EWL_FLAG_ALIGN_LEFT = 0x1, /**< Left align bit */
        EWL_FLAG_ALIGN_RIGHT = 0x2, /**< Right align bit */
        EWL_FLAG_ALIGN_TOP = 0x4, /**< Top align bit */
        EWL_FLAG_ALIGN_BOTTOM = 0x8, /**< Bottom align bit */

        /*
         * Fill policy identifies to containers whether child widgets should be
         * stretched to fill available space or keep their current size.
         */
        EWL_FLAG_FILL_NONE = 0, /**< Do not fill or shrink in any direction */
        EWL_FLAG_FILL_HSHRINKABLE = 0x10, /**< Horizontally shrink bit */
        EWL_FLAG_FILL_VSHRINKABLE = 0x20, /**< Vertical shrink bit */
        EWL_FLAG_FILL_SHRINKABLE =
                EWL_FLAG_FILL_HSHRINKABLE | EWL_FLAG_FILL_VSHRINKABLE, /**< Shrink bit */
        EWL_FLAG_FILL_HFILL = 0x40, /**< Horizontal fill bit */
        EWL_FLAG_FILL_VFILL = 0x80, /**< Vertical fill bit */
        EWL_FLAG_FILL_FILL = EWL_FLAG_FILL_HFILL | EWL_FLAG_FILL_VFILL, /**< Fill bit */
        EWL_FLAG_FILL_ALL = EWL_FLAG_FILL_FILL | EWL_FLAG_FILL_SHRINKABLE, /**< Shrunk and fill bit */
        EWL_FLAG_FILL_HSHRINK = 0x100 | EWL_FLAG_FILL_HSHRINKABLE, 
                                        /**< Horizontal unfold bit */
        EWL_FLAG_FILL_VSHRINK = 0x200 | EWL_FLAG_FILL_VSHRINKABLE, 
                                        /**< Horizontal unfold bit */
        EWL_FLAG_FILL_SHRINK = EWL_FLAG_FILL_HSHRINK | EWL_FLAG_FILL_VSHRINK
}

/**
 * @def EWL_FLAG_FILL_NORMAL
 * Flag specifing normal fill values
 */
const Ewl_Object_Flags EWL_FLAG_FILL_NORMAL = Ewl_Object_Flags.EWL_FLAG_FILL_FILL;

/**
 * @def EWL_FLAGS_ALIGN_MASK
 * The alignment mask
 */
const Ewl_Object_Flags EWL_FLAGS_ALIGN_MASK = (Ewl_Object_Flags.EWL_FLAG_ALIGN_CENTER |
												Ewl_Object_Flags.EWL_FLAG_ALIGN_LEFT | 
                								Ewl_Object_Flags.EWL_FLAG_ALIGN_RIGHT | 
                								Ewl_Object_Flags.EWL_FLAG_ALIGN_TOP | 
                								Ewl_Object_Flags.EWL_FLAG_ALIGN_BOTTOM);

/**
 * @def EWL_FLAGS_FILL_MASK
 * The fill mask
 */
const Ewl_Object_Flags EWL_FLAGS_FILL_MASK = (Ewl_Object_Flags.EWL_FLAG_FILL_NONE |
												Ewl_Object_Flags.EWL_FLAG_FILL_SHRINKABLE |
                								Ewl_Object_Flags.EWL_FLAG_FILL_FILL | 
                								Ewl_Object_Flags.EWL_FLAG_FILL_SHRINK);

/**
 * @enum Ewl_Widget_Flags
 * A variety of flags that affect visibility, scheduling and
 * properties of widgets.
 */
enum Ewl_Widget_Flags
{
        /*
         * Flags identifying the visibility status of the widget
         */
        EWL_FLAG_VISIBLE_HIDDEN   = 0,          /**< Widget hidden */
        EWL_FLAG_VISIBLE_SHOWN    = 0x1,        /**< Widget shown */
        EWL_FLAG_VISIBLE_REALIZED = 0x2,        /**< Widget realized */
        EWL_FLAG_VISIBLE_REVEALED = 0x4,        /**< Widget revealed */
        EWL_FLAG_VISIBLE_NOCLIP   = 0x8,        /**< Widget has no clip */

        /*
         * Behavior modifying properties.
         */
        EWL_FLAG_PROPERTY_RECURSIVE       = 0x10,   /**< Widget is recursive */
        EWL_FLAG_PROPERTY_TOPLEVEL        = 0x20,   /**< Widget is a top level widget */
        EWL_FLAG_PROPERTY_INTERNAL        = 0x40,   /**< Widget is internal */
        EWL_FLAG_PROPERTY_UNMANAGED       = 0x80,   /**< Widget is unmanaged */
        EWL_FLAG_PROPERTY_BLOCK_TAB_FOCUS = 0x100,  /**< Widget will block tab focus changes */
        EWL_FLAG_PROPERTY_FOCUSABLE       = 0x200,  /**< Widget is focusable */
        EWL_FLAG_PROPERTY_IN_TAB_LIST     = 0x400,  /**< Widget is in the tab order */
        EWL_FLAG_PROPERTY_DND_TARGET      = 0x800,  /**< Widget is DND aware */
        EWL_FLAG_PROPERTY_DND_SOURCE      = 0x1000, /**< Widget is dragable */
        EWL_FLAG_PROPERTY_TOPLAYERED      = 0x2000, /**< Widget is toplayered */

        /*
         * Flags to indicate queues this object is on.
         */
        EWL_FLAG_QUEUED_SCHEDULED_CONFIGURE = 0x4000,  /**< Configure scheduled */
        EWL_FLAG_QUEUED_SCHEDULED_REVEAL    = 0x8000,  /**< Reveal scheduled */
        EWL_FLAG_QUEUED_SCHEDULED_DESTROY   = 0x10000, /**< Delete scheduled */

        EWL_FLAG_QUEUED_PROCESS_CONFIGURE   = 0x20000, /**< Configure in progress */
        EWL_FLAG_QUEUED_PROCESS_REVEAL      = 0x40000, /**< Reveal in progress */
        EWL_FLAG_QUEUED_PROCESS_DESTROY     = 0x80000, /**< Delete in progress */

        /*
         * The state enum specifies the current state of a widget, ie. has it
         * been clicked, does it have the keyboard focus, etc.
         */
        EWL_FLAG_STATE_NORMAL   = 0,         /**< Widget state normal */
        EWL_FLAG_STATE_MOUSE_IN = 0x100000,  /**< Mouse is in the widget */
        EWL_FLAG_STATE_PRESSED  = 0x200000,  /**< Widget is pressed */
        EWL_FLAG_STATE_FOCUSED  = 0x400000,  /**< Widget has focus */
        EWL_FLAG_STATE_DISABLED = 0x800000,  /**< Widget is disabled */
        EWL_FLAG_STATE_DND      = 0x1000000, /**< Widget is engaged in DND */
};

/**
 * @def EWL_FLAGS_VISIBLE_MASK
 * The visibility mask
 */
const Ewl_Widget_Flags EWL_FLAGS_VISIBLE_MASK = (Ewl_Widget_Flags.EWL_FLAG_VISIBLE_HIDDEN |
                Ewl_Widget_Flags.EWL_FLAG_VISIBLE_SHOWN |
                Ewl_Widget_Flags.EWL_FLAG_VISIBLE_REALIZED |
                Ewl_Widget_Flags.EWL_FLAG_VISIBLE_REVEALED |
                Ewl_Widget_Flags.EWL_FLAG_VISIBLE_NOCLIP);

/**
 * @def EWL_FLAGS_PROPERTY_MASK
 * The property mask
 */
const Ewl_Widget_Flags EWL_FLAGS_PROPERTY_MASK = (Ewl_Widget_Flags.EWL_FLAG_PROPERTY_RECURSIVE 
                | Ewl_Widget_Flags.EWL_FLAG_PROPERTY_TOPLEVEL 
                | Ewl_Widget_Flags.EWL_FLAG_PROPERTY_INTERNAL 
                | Ewl_Widget_Flags.EWL_FLAG_PROPERTY_UNMANAGED 
                | Ewl_Widget_Flags.EWL_FLAG_PROPERTY_BLOCK_TAB_FOCUS 
                | Ewl_Widget_Flags.EWL_FLAG_PROPERTY_FOCUSABLE 
                | Ewl_Widget_Flags.EWL_FLAG_PROPERTY_DND_TARGET 
                | Ewl_Widget_Flags.EWL_FLAG_PROPERTY_DND_SOURCE 
                | Ewl_Widget_Flags.EWL_FLAG_PROPERTY_IN_TAB_LIST 
                | Ewl_Widget_Flags.EWL_FLAG_PROPERTY_TOPLAYERED);

/**
 * @def EWL_FLAGS_QUEUED_MASK
 * The queue mask
 */
const Ewl_Widget_Flags EWL_FLAGS_QUEUED_MASK = (Ewl_Widget_Flags.EWL_FLAG_QUEUED_SCHEDULED_CONFIGURE |
                Ewl_Widget_Flags.EWL_FLAG_QUEUED_SCHEDULED_REVEAL | 
                Ewl_Widget_Flags.EWL_FLAG_QUEUED_SCHEDULED_DESTROY |
                Ewl_Widget_Flags.EWL_FLAG_QUEUED_PROCESS_CONFIGURE | 
                Ewl_Widget_Flags.EWL_FLAG_QUEUED_PROCESS_REVEAL |
                Ewl_Widget_Flags.EWL_FLAG_QUEUED_PROCESS_DESTROY);

/**
 * @def EWL_FLAGS_STATE_MASK
 * The state mask
 */
const Ewl_Widget_Flags EWL_FLAGS_STATE_MASK = (Ewl_Widget_Flags.EWL_FLAG_STATE_NORMAL | 
                Ewl_Widget_Flags.EWL_FLAG_STATE_MOUSE_IN | 
                Ewl_Widget_Flags.EWL_FLAG_STATE_PRESSED | 
                Ewl_Widget_Flags.EWL_FLAG_STATE_FOCUSED | 
                Ewl_Widget_Flags.EWL_FLAG_STATE_DND | 
                Ewl_Widget_Flags.EWL_FLAG_STATE_DISABLED);

/**
 * @enum Ewl_Position
 * The possible placement positions
 */
enum Ewl_Position
{
        EWL_POSITION_LEFT = 0x1,        /**< Left position */
        EWL_POSITION_RIGHT = 0x2,        /**< Right position */
        EWL_POSITION_TOP = 0x4,                /**< Top position */
        EWL_POSITION_BOTTOM = 0x8        /**< Bottom position */
}

/**
 * @def EWL_POSITION_MASK
 * The mask for the Ewl_Position bitmap
 */
const int EWL_POSITION_MASK = 0xf;

/**
 * @enum Ewl_Window_Flags
 * The possible window states
 */
enum Ewl_Window_Flags
{
        EWL_WINDOW_BORDERLESS = 0x1,                /**< Window is borderless */
        EWL_WINDOW_USER_CONFIGURE = 0x2,        /**< User configure */
        EWL_WINDOW_GRAB_POINTER = 0x4,                /**< Window grabs pointer */
        EWL_WINDOW_GRAB_KEYBOARD = 0x8,                /**< Window grabs keyboard */
        EWL_WINDOW_OVERRIDE = 0x10,                /**< Window override setting */
        EWL_WINDOW_FULLSCREEN = 0x20,                /**< Window is fullscreen */
        EWL_WINDOW_DIALOG = 0x40,                /**< Window has no max and min buttons */
        EWL_WINDOW_MODAL = 0x80,                /**< Window is modal */
        EWL_WINDOW_TRANSIENT = 0x100,                /**< Window is transient for */
        EWL_WINDOW_TRANSIENT_FOREIGN = 0x200,        /**< Window is transient for */
        EWL_WINDOW_LEADER = 0x400,                /**< Window HAS a leader */
        EWL_WINDOW_LEADER_FOREIGN = 0x800,        /**< Window HAS a leader */
        EWL_WINDOW_SKIP_TASKBAR = 0x1000,        /**< Window skips taskbar */
        EWL_WINDOW_SKIP_PAGER = 0x2000,                /**< Window skips pager */
        EWL_WINDOW_DEMANDS_ATTENTION = 0x4000,        /**< Window requires attention */
        EWL_WINDOW_URGENT = 0x8000                /**< Window is urgent */
}

/**
 * @enum Ewl_Popup_Type
 * The possible popup types
 */
enum Ewl_Popup_Type
{
        EWL_POPUP_TYPE_NONE,                /**< No popup type */
        EWL_POPUP_TYPE_MOUSE,                /**< Popup off the mouse */
        EWL_POPUP_TYPE_MENU_HORIZONTAL,        /**< Popup with horizontal data */
        EWL_POPUP_TYPE_MENU_VERTICAL        /**< Popup with vertical data */
}

/**
 * @enum Ewl_Tree_Node_Flags
 * The available tree node states
 */
enum Ewl_Tree_Node_Flags
{
        EWL_TREE_NODE_NOEXPAND = 0,        /**< Node does not expand */
        EWL_TREE_NODE_COLLAPSED = 1,        /**< Node is collapsed */
        EWL_TREE_NODE_EXPANDED = 2,        /**< Node is expanded */
}

/**
 * @enum Ewl_Notebook_Flags
 * States effecting the notebook
 */
enum Ewl_Notebook_Flags
{
        EWL_NOTEBOOK_FLAG_TABS_HIDDEN = 0x10        /**< Tabbar is hidden */
}

/**
 * @enum Ewl_Scrollpane_Flags
 * The possible scrollpane settings
 */
enum Ewl_Scrollpane_Flags
{
        EWL_SCROLLPANE_FLAG_NONE,                /**< No flags set */
        EWL_SCROLLPANE_FLAG_AUTO_VISIBLE,        /**< Hide if possible */
        EWL_SCROLLPANE_FLAG_ALWAYS_HIDDEN        /**< Always hide */
}

/**
 * @enum Ewl_Key_Modifiers
 * The key modifiers
 */
enum Ewl_Key_Modifiers
{
        EWL_KEY_MODIFIER_SHIFT = 0x1,        /**< Shift key */
        EWL_KEY_MODIFIER_CTRL = 0x2,        /**< Ctrl key */
        EWL_KEY_MODIFIER_ALT = 0x4,        /**< Alt key */
        EWL_KEY_MODIFIER_MOD = 0x8,        /**< Mod key */
        EWL_KEY_MODIFIER_WIN = 0x10,        /**< Win key */
}

/**
 * @enum Ewl_State_Type
 * The state type
 */
enum Ewl_State_Type
{
        EWL_STATE_TRANSIENT,
        EWL_STATE_PERSISTENT
}

/**
 * @enum Ewl_Stock_Type
 * The different stock types
 */
enum Ewl_Stock_Type
{
        EWL_STOCK_ABOUT = 0,
        EWL_STOCK_ADD,
        EWL_STOCK_APPLY,
        EWL_STOCK_ARROW_BOTTOM,
        EWL_STOCK_ARROW_DOWN,
        EWL_STOCK_ARROW_FIRST,
        EWL_STOCK_ARROW_LAST,
        EWL_STOCK_ARROW_LEFT,
        EWL_STOCK_ARROW_RIGHT,
        EWL_STOCK_ARROW_TOP,
        EWL_STOCK_ARROW_UP,
        EWL_STOCK_BOLD,
        EWL_STOCK_CANCEL,
        EWL_STOCK_CLEAR,
        EWL_STOCK_CLOSE,
        EWL_STOCK_COPY,
        EWL_STOCK_CUT,
        EWL_STOCK_DELETE,
        EWL_STOCK_EDIT,
        EWL_STOCK_EXECUTE,
        EWL_STOCK_FIND,
        EWL_STOCK_FIND_REPLACE,
        EWL_STOCK_FULLSCREEN,
        EWL_STOCK_HELP,
        EWL_STOCK_HOME,
        EWL_STOCK_INDENT,
        EWL_STOCK_ITALIC,
        EWL_STOCK_JUSTIFY_CENTER,
        EWL_STOCK_JUSTIFY_FILL,
        EWL_STOCK_JUSTIFY_LEFT,
        EWL_STOCK_JUSTIFY_RIGHT,
        EWL_STOCK_MEDIA_FASTFORWARD,
        EWL_STOCK_MEDIA_NEXT,
        EWL_STOCK_MEDIA_PAUSE,
        EWL_STOCK_MEDIA_PLAY,
        EWL_STOCK_MEDIA_PREVIOUS,
        EWL_STOCK_MEDIA_RECORD,
        EWL_STOCK_MEDIA_REWIND,
        EWL_STOCK_MEDIA_STOP,
        EWL_STOCK_NEW,
        EWL_STOCK_OK,
        EWL_STOCK_OPEN,
        EWL_STOCK_PASTE,
        EWL_STOCK_PREFERENCES,
        EWL_STOCK_PRINT,
        EWL_STOCK_PRINT_PREVIEW,
        EWL_STOCK_PROPERTIES,
        EWL_STOCK_QUIT,
        EWL_STOCK_REDO,
        EWL_STOCK_REFRESH,
        EWL_STOCK_REMOVE,
        EWL_STOCK_SAVE,
        EWL_STOCK_SAVE_AS,
        EWL_STOCK_SELECT_ALL,
        EWL_STOCK_SORT_ASCENDING,
        EWL_STOCK_SORT_DESCENDING,
        EWL_STOCK_SPELL_CHECK,
        EWL_STOCK_STRIKETHROUGH,
        EWL_STOCK_UNDERLINE,
        EWL_STOCK_UNDO,
        EWL_STOCK_UNINDENT,
        EWL_STOCK_ZOOM_100,
        EWL_STOCK_ZOOM_FIT,
        EWL_STOCK_ZOOM_IN,
        EWL_STOCK_ZOOM_OUT,
        EWL_STOCK_NONE
}

/**
 * @enum Ewl_Color_Mode
 * The different colour picker modes
 */
enum Ewl_Color_Mode
{
        EWL_COLOR_MODE_RGB_RED,
        EWL_COLOR_MODE_RGB_GREEN,
        EWL_COLOR_MODE_RGB_BLUE,
        EWL_COLOR_MODE_HSV_HUE,
        EWL_COLOR_MODE_HSV_SATURATION,
        EWL_COLOR_MODE_HSV_VALUE
}

/**
 * @enum Ewl_Spectrum_Type
 * The spectrum types
 */
enum Ewl_Spectrum_Type
{
        EWL_SPECTRUM_TYPE_SQUARE,
        EWL_SPECTRUM_TYPE_VERTICAL
}

/**
 * @enum Ewl_Text_Style
 * The possible styles that can be set into ewl_text widgets
 */
enum Ewl_Text_Style
{
        EWL_TEXT_STYLE_NONE = 0x00,
        EWL_TEXT_STYLE_UNDERLINE = 0x01,
        EWL_TEXT_STYLE_DOUBLE_UNDERLINE = 0x02,
        EWL_TEXT_STYLE_STRIKETHROUGH = 0x04,
        EWL_TEXT_STYLE_SHADOW = 0x08,
        EWL_TEXT_STYLE_SOFT_SHADOW = 0x10,
        EWL_TEXT_STYLE_FAR_SHADOW = 0x20,
        EWL_TEXT_STYLE_OUTLINE = 0x40,
        EWL_TEXT_STYLE_GLOW = 0x80
}

/**
 * @enum Ewl_Text_Trigger_Type
 * The types of trigger that can be set
 */
enum Ewl_Text_Trigger_Type
{
        EWL_TEXT_TRIGGER_TYPE_NONE,
        EWL_TEXT_TRIGGER_TYPE_SELECTION,
        EWL_TEXT_TRIGGER_TYPE_TRIGGER
}

/**
 * @enum Ewl_Attach_Type
 * The types that can be attached to a widget
 */
enum Ewl_Attach_Type
{
        EWL_ATTACH_TYPE_TOOLTIP,
        EWL_ATTACH_TYPE_COLOR,
        EWL_ATTACH_TYPE_NAME,
        EWL_ATTACH_TYPE_MOUSE_CURSOR,
        EWL_ATTACH_TYPE_MOUSE_ARGB_CURSOR,
        EWL_ATTACH_TYPE_WIDGET_ASSOCIATION,
        EWL_ATTACH_TYPE_DND_DATA
}

/**
 * @enum Ewl_Attach_Data_Type
 * The types of data that can be set into a widgets attachment
 */
enum Ewl_Attach_Data_Type
{
        EWL_ATTACH_DATA_TYPE_TEXT,
        EWL_ATTACH_DATA_TYPE_WIDGET,
        EWL_ATTACH_DATA_TYPE_OTHER
}

/**
 * @enum Ewl_Media_Module_Type
 * The possible modules to use with ewl_media
 */
enum Ewl_Media_Module_Type
{
        EWL_MEDIA_MODULE_XINE,
        EWL_MEDIA_MODULE_GSTREAMER
}

/**
 * @enum Ewl_Text_Context_Mask
 * The possible context masks for the ewl_text
 */
enum Ewl_Text_Context_Mask
{
        EWL_TEXT_CONTEXT_MASK_NONE = 0x00,
        EWL_TEXT_CONTEXT_MASK_FONT = 0x01,
        EWL_TEXT_CONTEXT_MASK_SIZE = 0x02,
        EWL_TEXT_CONTEXT_MASK_STYLES = 0x04,
        EWL_TEXT_CONTEXT_MASK_ALIGN = 0x08,
        EWL_TEXT_CONTEXT_MASK_WRAP = 0x10,
        EWL_TEXT_CONTEXT_MASK_COLOR = 0x20,
        EWL_TEXT_CONTEXT_MASK_BG_COLOR = 0x40,
        EWL_TEXT_CONTEXT_MASK_GLOW_COLOR = 0x80,
        EWL_TEXT_CONTEXT_MASK_OUTLINE_COLOR = 0x100,
        EWL_TEXT_CONTEXT_MASK_SHADOW_COLOR = 0x200,
        EWL_TEXT_CONTEXT_MASK_STRIKETHROUGH_COLOR = 0x400,
        EWL_TEXT_CONTEXT_MASK_UNDERLINE_COLOR = 0x800,
        EWL_TEXT_CONTEXT_MASK_DOUBLE_UNDERLINE_COLOR = 0x1000
}

/**
 * @enum Ewl_Icon_Type
 * The possible icon types
 */
enum Ewl_Icon_Type
{
        EWL_ICON_TYPE_SHORT,
        EWL_ICON_TYPE_LONG
}

/**
 * @enum Ewl_Icon_Part
 * The different Parts of an Icon
 */
enum Ewl_Icon_Part
{
        EWL_ICON_PART_NONE,
        EWL_ICON_PART_IMAGE,
        EWL_ICON_PART_LABEL
}

/**
 * @enum Ewl_Freebox_Layout_Type
 * The possibly layout settings for the freebox
 */
enum Ewl_Freebox_Layout_Type
{
        EWL_FREEBOX_LAYOUT_MANUAL,
        EWL_FREEBOX_LAYOUT_COMPARATOR,
        EWL_FREEBOX_LAYOUT_AUTO
}

/**
 * @enum Ewl_Filelist_Event_Type
 * The possible events that can happen from the filelist
 */
enum Ewl_Filelist_Event_Type
{
        EWL_FILELIST_EVENT_DIR_CHANGE,
        EWL_FILELIST_EVENT_SELECTION_CHANGE,
        EWL_FILELIST_EVENT_FILE_SELECTED,
        EWL_FILELIST_EVENT_MULTI_TRUE,
        EWL_FILELIST_EVENT_MULTI_FALSE
}

/**
 * @enum Ewl_Grid_Resize_Type
 * The different ways of resizing a column or a row
 */
enum Ewl_Grid_Resize_Type
{
        EWL_GRID_RESIZE_NORMAL,                /**< use the standard resize methode */
        EWL_GRID_RESIZE_FIXED,                /**< use the user set size */
        EWL_GRID_RESIZE_RELATIVE,        /**< use the user set relative size */
        EWL_GRID_RESIZE_NONE                /**< use the preferred size of the row */
}

/**
 * @enum Ewl_Mouse_Cursor_Type
 * The possible mouse cursor settings
 */
enum Ewl_Mouse_Cursor_Type
{
        EWL_MOUSE_CURSOR_X = 0,
        EWL_MOUSE_CURSOR_ARROW = 2,
        EWL_MOUSE_CURSOR_BASED_ARROW_DOWN = 4,
        EWL_MOUSE_CURSOR_UP = 6,
        EWL_MOUSE_CURSOR_BOAT = 8,
        EWL_MOUSE_CURSOR_BOTTOM_LEFT_CORNER = 12,
        EWL_MOUSE_CURSOR_BOTTOM_RIGHT_CORNER = 14,
        EWL_MOUSE_CURSOR_BOTTOM_SIDE = 16,
        EWL_MOUSE_CURSOR_BOTTOM_TEE = 18,
        EWL_MOUSE_CURSOR_BOX_SPIRAL = 20,
        EWL_MOUSE_CURSOR_CENTER_PTR = 22,
        EWL_MOUSE_CURSOR_CIRCLE = 24,
        EWL_MOUSE_CURSOR_CLOCK = 26,
        EWL_MOUSE_CURSOR_COFFEE_MUG = 28,
        EWL_MOUSE_CURSOR_CROSS = 30,
        EWL_MOUSE_CURSOR_CROSS_REVERSE = 32,
        EWL_MOUSE_CURSOR_CROSSHAIR = 34,
        EWL_MOUSE_CURSOR_DIAMOND_CROSS = 36,
        EWL_MOUSE_CURSOR_DOT = 38,
        EWL_MOUSE_CURSOR_DOT_BOX_MASK = 40,
        EWL_MOUSE_CURSOR_DOUBLE_ARROW = 42,
        EWL_MOUSE_CURSOR_DRAFT_LARGE = 44,
        EWL_MOUSE_CURSOR_DRAFT_SMALL = 46,
        EWL_MOUSE_CURSOR_DRAPED_BOX = 48,
        EWL_MOUSE_CURSOR_EXCHANGE = 50,
        EWL_MOUSE_CURSOR_FLEUR = 52,
        EWL_MOUSE_CURSOR_GOBBLER = 54,
        EWL_MOUSE_CURSOR_GUMBY = 56,
        EWL_MOUSE_CURSOR_HAND1 = 58,
        EWL_MOUSE_CURSOR_HAND2 = 60,
        EWL_MOUSE_CURSOR_HEART = 62,
        EWL_MOUSE_CURSOR_ICON = 64,
        EWL_MOUSE_CURSOR_IRON_CROSS = 66,
        EWL_MOUSE_CURSOR_LEFT_PTR = 68,
        EWL_MOUSE_CURSOR_LEFT_SIDE = 70,
        EWL_MOUSE_CURSOR_LEFT_TEE = 72,
        EWL_MOUSE_CURSOR_LEFTBUTTON = 74,
        EWL_MOUSE_CURSOR_LL_ANGLE = 76,
        EWL_MOUSE_CURSOR_LR_ANGLE = 78,
        EWL_MOUSE_CURSOR_MAN = 80,
        EWL_MOUSE_CURSOR_MIDDLEBUTTON = 82,
        EWL_MOUSE_CURSOR_MOUSE = 84,
        EWL_MOUSE_CURSOR_PENCIL = 86,
        EWL_MOUSE_CURSOR_PIRATE = 88,
        EWL_MOUSE_CURSOR_PLUS = 90,
        EWL_MOUSE_CURSOR_QUESTION_ARROW = 92,
        EWL_MOUSE_CURSOR_RIGHT_PTR = 94,
        EWL_MOUSE_CURSOR_RIGHT_SIDE = 96,
        EWL_MOUSE_CURSOR_RIGHT_TEE = 98,
        EWL_MOUSE_CURSOR_RIGHTBUTTON = 100,
        EWL_MOUSE_CURSOR_RTL_LOGO = 102,
        EWL_MOUSE_CURSOR_SAILBOAT = 104,
        EWL_MOUSE_CURSOR_SB_DOWN_ARROW = 106,
        EWL_MOUSE_CURSOR_SB_H_DOUBLE_ARROW = 108,
        EWL_MOUSE_CURSOR_SB_LEFT_ARROW = 110,
        EWL_MOUSE_CURSOR_SB_RIGHT_ARROW = 112,
        EWL_MOUSE_CURSOR_SB_UP_ARROW = 114,
        EWL_MOUSE_CURSOR_SB_V_DOUBLE_ARROW = 116,
        EWL_MOUSE_CURSOR_SHUTTLE = 118,
        EWL_MOUSE_CURSOR_SIZING = 120,
        EWL_MOUSE_CURSOR_SPIDER = 122,
        EWL_MOUSE_CURSOR_SPRAYCAN = 124,
        EWL_MOUSE_CURSOR_STAR = 126,
        EWL_MOUSE_CURSOR_TARGET = 128,
        EWL_MOUSE_CURSOR_TCROSS = 130,
        EWL_MOUSE_CURSOR_TOP_LEFT_ARROW = 132,
        EWL_MOUSE_CURSOR_TOP_LEFT_CORNER = 134,
        EWL_MOUSE_CURSOR_TOP_RIGHT_CORNER = 136,
        EWL_MOUSE_CURSOR_TOP_SIDE = 138,
        EWL_MOUSE_CURSOR_TOP_TEE = 140,
        EWL_MOUSE_CURSOR_TREK = 142,
        EWL_MOUSE_CURSOR_UL_ANGLE = 144,
        EWL_MOUSE_CURSOR_UMBRELLA = 146,
        EWL_MOUSE_CURSOR_UR_ANGLE = 148,
        EWL_MOUSE_CURSOR_WATCH = 150,
        EWL_MOUSE_CURSOR_XTERM = 152,
        EWL_MOUSE_CURSOR_MAX = 153
}

/**
 * @enum Ewl_Sort_Direction
 * The current sort direction
 */
enum Ewl_Sort_Direction
{
        EWL_SORT_DIRECTION_NONE = 0,
        EWL_SORT_DIRECTION_ASCENDING,
        EWL_SORT_DIRECTION_DESCENDING,
        EWL_SORT_DIRECTION_MAX
}

/**
 * @enum Ewl_Text_Wrap
 * The text wrap setting
 */
enum Ewl_Text_Wrap
{
        EWL_TEXT_WRAP_NONE = 0,
        EWL_TEXT_WRAP_CHAR,
        EWL_TEXT_WRAP_WORD
}

/**
 * @enum Ewl_Rotate
 * The rotate values
 */
enum Ewl_Rotate
{
        EWL_ROTATE_CW_90,        /**< 90 degree clockwise rotation */
        EWL_ROTATE_180,                /**< 180 degree rotation */
        EWL_ROTATE_CW_270,        /**< 270 degree clockwise rotation */
        EWL_ROTATE_CC_90,        /**< 90 degree counter-clockwise rotation */
        EWL_ROTATE_CC_270        /**< 270 degree counter-clockwise rotation */
}

/**
 * @enum Ewl_Selection_Type
 * The selection type enum
 */
enum Ewl_Selection_Type
{
        EWL_SELECTION_TYPE_INDEX,        /**< Single index */
        EWL_SELECTION_TYPE_RANGE        /**< Range of indices */
}

/**
 * @enum Ewl_Selection_Mode
 * The slecetion mode enum
 */
enum Ewl_Selection_Mode
{
        EWL_SELECTION_MODE_NONE,        /**< No selection allowed */
        EWL_SELECTION_MODE_SINGLE,        /**< Single select only */
        EWL_SELECTION_MODE_MULTI        /**< Multi select mode */
}

/**
 * @enum Ewl_Tree_Selection_Type
 * The tree selection type
 */
enum Ewl_Tree_Selection_Type
{
        EWL_TREE_SELECTION_TYPE_ROW,        /**< Row selection */
        EWL_TREE_SELECTION_TYPE_CELL        /**< Cell selection */
}

/**
 * @enum Ewl_Histogram_Channel
 * The histogram channels
 */
enum Ewl_Histogram_Channel
{
        EWL_HISTOGRAM_CHANNEL_Y,
        EWL_HISTOGRAM_CHANNEL_R,
        EWL_HISTOGRAM_CHANNEL_G,
        EWL_HISTOGRAM_CHANNEL_B,
        EWL_HISTOGRAM_CHANNEL_MAX
}

/**
 * @enum Ewl_Image_Type
 * The type of image
 */
enum Ewl_Image_Type
{
        EWL_IMAGE_TYPE_NORMAL, /**< Standard image type */
        EWL_IMAGE_TYPE_EDJE /**< Edje image type */
}

/**
 * @enum Ewl_Thumbnail_Size
 * The size of thumbnails
 */

enum Ewl_Thumbnail_Size
{
        EWL_THUMBNAIL_SIZE_NORMAL, /**< Normal size thumbnail */
        EWL_THUMBNAIL_SIZE_LARGE, /**< A large thumbnail*/
}


/**
 * @enum Ewl_Filelist_View
 * The view used in the filelist
 */
enum Ewl_Filelist_View
{
        EWL_FILELIST_VIEW_ICON, /**< Uses freebox view of tree */
        EWL_FILELIST_VIEW_LIST, /**< Normal tree with no expansions */
        EWL_FILELIST_VIEW_TREE, /**< Normal tree with expansions */
        EWL_FILELIST_VIEW_COLUMN, /**< A custom column view */
}

/**
 * @enum Ewl_Kinetic_Scroll
 * The type of kinetic scrolling
 */
enum Ewl_Kinetic_Scroll
{
        EWL_KINETIC_SCROLL_NONE,
        EWL_KINETIC_SCROLL_NORMAL,
        EWL_KINETIC_SCROLL_EMBEDDED
}

/**
 * @addtogroup Ewl_Object Ewl_Object: Base object. Provides functionality available to all widgets.
 * @brief Defines the Ewl_Object class along with basic methods and macros.
 *
 * @{
 */

/**
 * @def EWL_OBJECT_MIN_SIZE
 * The minimum possible size any object can receive.
 */
const int EWL_OBJECT_MIN_SIZE = 1;

/**
 * @def EWL_OBJECT_MAX_SIZE
 * The maximum possible size any object can receive.
 */
const int EWL_OBJECT_MAX_SIZE = int.max;

/**
 * @def EWL_OBJECT(object)
 * A typecast for accessing the inherited object fields.
 */
Ewl_Object* EWL_OBJECT(void* o)
{
	return cast(Ewl_Object*) o;	
}

/**
 * @brief Provides facilities for sizing, position, alignment and fill policy.
 *
 * The fields of the object, while their explanations are fairly clear, can be
 * visualized with the following diagram:
 *
 * @image html object_fields.png
 *
 * The CURRENT_W(w) and CURRENT_H(w) are macros that provide easy access to the
 * data fields describing the internal area of the Ewl_Object. While the
 * functions ewl_object_get_current_w(w) and ewl_object_get_current_h(w) are
 * to access the overall size of the area this Ewl_Object resides in. There
 * are corresponding macros and functions for preferred, minimum and maximum
 * sizes as well. There are also functions for setting each of these values.
 *
 * The affect of the fields when performing layout is as follows:
 *
 * @image html object_sizing.png
 *
 * As illustrated, the fill policy determines how much space an object will
 * use when the request for a specific size is made. When the fill policy
 * contains EWL_FLAG_FILL_HSHRINKABLE, EWL_FLAG_FILL_VSHRINKABLE or both, the
 * Ewl_Object can be resized down to it's minimum size in width, height or both
 * respectively.
 *
 * The opposite is true for a fill policy containing EWL_FLAG_FILL_HFILL,
 * EWL_FLAG_FILL_VFILL or both, The Ewl_Object will now expand to fill the
 * space up to it's maximum size in the respective direction.
 */
struct Ewl_Object
{
        struct SizeAndPosition
        {
                int x; /**< Horizontal position */
                int y; /**< Vertical position */
                int w; /**< Width */
                int h; /**< Height */
        }
        
        SizeAndPosition current; /**< The current size and position of an object. */

        struct Dimensions
        {
                int w; /**< Width */
                int h; /**< Height */
        }
        
        Dimensions preferred; /**< The optimal size of the object in ideal circumstances */
        Dimensions maximum; /**< The guaranteed maximum size this object will receive. */
        Dimensions minimum; /**< The guaranteed minimum size this object will receive. */

        struct Box
        {
                short l, /**< Left value */
                      r, /**< Right value */
                      t, /**< Top value */
                      b; /**< Bottom value */
        } 
        
        Box pad;    /**< The space padded around the outside of the object. */
        Box insets; /**< The space inside where children should not be laid out. */

        uint flags; /**< Bitmask indicating fill policy and alignment */
}

int              ewl_object_init(Ewl_Object* o);
void             ewl_object_current_geometry_get(Ewl_Object* o, int* x, int* y,
                                                int* w, int* h);

void             ewl_object_current_size_get(Ewl_Object* o, int* w, int* h);
int              ewl_object_current_x_get(Ewl_Object* o);
int              ewl_object_current_y_get(Ewl_Object* o);
int              ewl_object_current_w_get(Ewl_Object* o);
int              ewl_object_current_h_get(Ewl_Object* o);

void             ewl_object_preferred_inner_size_set(Ewl_Object* o, int w, int h);
void             ewl_object_preferred_inner_size_get(Ewl_Object* o, int* w, int* h);
void             ewl_object_preferred_size_get(Ewl_Object* o, int* w, int* h);

void             ewl_object_preferred_inner_w_set(Ewl_Object* o, int w);
int              ewl_object_preferred_w_get(Ewl_Object* o);
int              ewl_object_preferred_inner_w_get(Ewl_Object* o);

void             ewl_object_preferred_inner_h_set(Ewl_Object* o, int h);
int              ewl_object_preferred_inner_h_get(Ewl_Object* o);
int              ewl_object_preferred_h_get(Ewl_Object* o);

void             ewl_object_geometry_request(Ewl_Object* o, int x, int y,
                                             int w, int h);
void             ewl_object_size_request(Ewl_Object* o, int w, int h);
void             ewl_object_position_request(Ewl_Object* o, int x, int y);
void             ewl_object_x_request(Ewl_Object* o, int x);
void             ewl_object_y_request(Ewl_Object* o, int y);
void             ewl_object_w_request(Ewl_Object* o, int w);
void             ewl_object_h_request(Ewl_Object* o, int h);

void             ewl_object_minimum_size_set(Ewl_Object* o, int w, int h);
void             ewl_object_minimum_w_set(Ewl_Object* o, int w);
void             ewl_object_minimum_h_set(Ewl_Object* o, int h);

void             ewl_object_minimum_size_get(Ewl_Object* o, int* w, int* h);
int              ewl_object_minimum_w_get(Ewl_Object* o);
int              ewl_object_minimum_h_get(Ewl_Object* o);

void             ewl_object_maximum_size_set(Ewl_Object* o, int w, int h);
void             ewl_object_maximum_w_set(Ewl_Object* o, int w);
void             ewl_object_maximum_h_set(Ewl_Object* o, int h);

void             ewl_object_maximum_size_get(Ewl_Object* o, int* w, int* h);
int              ewl_object_maximum_w_get(Ewl_Object* o);
int              ewl_object_maximum_h_get(Ewl_Object* o);

uint             ewl_object_alignment_get(Ewl_Object* o);
void             ewl_object_alignment_set(Ewl_Object* o, uint align_);
void             ewl_object_place(Ewl_Object* o, int x, int y, int w, int h);

uint             ewl_object_fill_policy_get(Ewl_Object* o);
void             ewl_object_fill_policy_set(Ewl_Object* o, uint fill);

/*
*  Padding setting and retrieval functions.
*/
void             ewl_object_padding_set(Ewl_Object* o, int l, int r, int t,
                                        int b);
void             ewl_object_padding_get(Ewl_Object* o, int* l, int* r, int* t,
                                       int* b);
int              ewl_object_padding_top_get(Ewl_Object* o);
int              ewl_object_padding_bottom_get(Ewl_Object* o);
int              ewl_object_padding_left_get(Ewl_Object* o);
int              ewl_object_padding_right_get(Ewl_Object* o);

/*
*  Inset setting and retrieval functions.
*/
void             ewl_object_insets_set(Ewl_Object* o, int l, int r, int t,
                                       int b);
void             ewl_object_insets_get(Ewl_Object* o, int* l, int* r, int* t,
                                       int* b);
int              ewl_object_insets_top_get(Ewl_Object* o);
int              ewl_object_insets_bottom_get(Ewl_Object* o);
int              ewl_object_insets_left_get(Ewl_Object* o);
int              ewl_object_insets_right_get(Ewl_Object* o);

void             ewl_object_flags_add(Ewl_Object* o, uint flags,
                                      uint mask);
void             ewl_object_flags_remove(Ewl_Object* o, uint flags,
                                         uint mask);

/**
*  @def PADDING_TOP(o)
*  Retrieve the size of the top pad
*/
short PADDING_TOP(void* o) 
{
	return EWL_OBJECT(o).pad.t;
}

/**
*  @def PADDING_BOTTOM(o)
*  Retrieve the size of the bottom pad
*/
short PADDING_BOTTOM(void* o) 
{
	return EWL_OBJECT(o).pad.b;
}

/**
*  @def PADDING_LEFT(o)
*  Retrieve the size of the left pad
*/
short PADDING_LEFT(void* o) 
{
	return EWL_OBJECT(o).pad.l;
}

/**
*  @def PADDING_RIGHT(o)
*  Retrieve the size of the right pad
*/
short PADDING_RIGHT(void* o) 
{
	return EWL_OBJECT(o).pad.r;
}

/**
*  @def PADDING_HORIZONTAL(o)
*  Retrieve the total size of the horizontal padding
*/
short PADDING_HORIZONTAL(void* o) 
{
	return (EWL_OBJECT(o).pad.l + EWL_OBJECT(o).pad.r);
}
/**
*  @def PADDING_VERTICAL(o)
*  Retrieve the total size of the vertical padding
*/
short PADDING_VERTICAL(void* o)
{
	return (EWL_OBJECT(o).pad.t + EWL_OBJECT(o).pad.b);
}

/**
*  @def INSET_LEFT(o)
*  Retrieve the size of the left inset
*/
short INSET_LEFT(void* o) {
	return EWL_OBJECT(o).insets.l;
}

/**
*  @def INSET_RIGHT(o)
*  Retrieve the size of the right inset
*/
short INSET_RIGHT(void* o) {
	return EWL_OBJECT(o).insets.r;
}

/**
*  @def INSET_TOP(o)
*  Retrieve the size of the top inset
*/
short INSET_TOP(void* o) {
	return EWL_OBJECT(o).insets.t;
}

/**
*  @def INSET_BOTTOM(o)
*  Retrieve the size of the bottom inset
*/
short INSET_BOTTOM(void* o) {
	return EWL_OBJECT(o).insets.b;
}

/**
*  @def INSET_HORIZONTAL(o)
*  Retrieve the total size of the horizontal insets for the object
*/
short INSET_HORIZONTAL(void* o)
{
	return (EWL_OBJECT(o).insets.l + EWL_OBJECT(o).insets.r);
}

/**
*  @def INSET_VERTICAL(o)
*  Retrieve the total size of the vertical insets for the object
*/
short INSET_VERTICAL(void* o) 
{
	return (EWL_OBJECT(o).insets.t + EWL_OBJECT(o).insets.b);
}
/**
*  @def CURRENT_X(o)
*  Retrieve the current x position of the object
*/
short CURRENT_X(void* o) 
{
	return EWL_OBJECT(o).current.x;
}
/**
*  @def CURRENT_Y(o)
*  Retrieve the current y position of the object
*/
short CURRENT_Y(void* o) 
{
	return EWL_OBJECT(o).current.y;
}
/**
*  @def CURRENT_W(o)
*  Retrieve the current width of the object without insets or padding
*/
short CURRENT_W(void* o) 
{
	return EWL_OBJECT(o).current.w;
}
/**
*  @def CURRENT_H(o)
*  Retrieve the current height of the object without insets or padding
*/
short CURRENT_H(void* o) 
{
	return EWL_OBJECT(o).current.h;
}
/**
*  @def PREFERRED_W(o)
*  Retrieve the preferred width of the widget
*/
short PREFERRED_W(void* o) 
{
	return EWL_OBJECT(o).preferred.w;
}
/**
*  @def PREFERRED_H(o)
*  Retrieve the preferred height of the widget
*/
short PREFERRED_H(void* o) 
{
	return EWL_OBJECT(o).preferred.h;
}
/**
*  @def MAXIMUM_W(o)
*  Retrieve the maximum width of the widget
*/
short MAXIMUM_W(void* o) 
{
	return EWL_OBJECT(o).maximum.w;
}
/**
*  @def MAXIMUM_H(o)
*  Retrieve the maximum height of the object
*/
short MAXIMUM_H(void* o) 
{
	return EWL_OBJECT(o).maximum.h;
}
/**
*  @def MINIMUM_W(o)
*  Retrieve the minimum width of the object
*/
short MINIMUM_W(void* o) 
{
	return EWL_OBJECT(o).minimum.w;
}
/**
*  @def MINIMUM_H(o)
*  Retrieve the minimum height of the object
*/
short MINIMUM_H(void* o) 
{
	return EWL_OBJECT(o).minimum.h;
}
/**
*  @def ewl_object_custom_size_set(o, w, h)
*  @param o: The object to work with
*  @param w: The width to set
*  @param h: The height to set
*  A convenience method to set a custom size onto a widget
*/
void ewl_object_custom_size_set(Ewl_Object* o, short w, short h)
{
	ewl_object_minimum_size_set(o, w, h);
	ewl_object_maximum_size_set(o, w, h);
	ewl_object_fill_policy_set(o, Ewl_Object_Flags.EWL_FLAG_FILL_NONE);
}

/**
*  @def ewl_object_custom_w_set(o, w)
*  @param o: The object to work with
*  @param w: The width to set
*  A convenience method to set a custom width onto a widget
*/
void ewl_object_custom_w_set(Ewl_Object* o, short w)
{
	ewl_object_maximum_w_set(o, w);
	ewl_object_minimum_w_set(o, w);
	ewl_object_fill_policy_set(o, ewl_object_fill_policy_get(o) &
	~(Ewl_Object_Flags.EWL_FLAG_FILL_HFILL | Ewl_Object_Flags.EWL_FLAG_FILL_HSHRINKABLE));
}

/**
*  @def ewl_object_custom_h_set(o, h)
*  @param o: The object to work with
*  @param h: The height to set
*  A convenience method to set a custom height onto a widget
*/
void ewl_object_custom_h_set(Ewl_Object* o, short h)
{
	ewl_object_maximum_h_set(o, h);
	ewl_object_minimum_h_set(o, h);
	ewl_object_fill_policy_set(o, ewl_object_fill_policy_get(o) &
		~(Ewl_Object_Flags.EWL_FLAG_FILL_VFILL | Ewl_Object_Flags.EWL_FLAG_FILL_VSHRINKABLE));
}
